"""
配置管理器

提供统一的配置管理接口，简化CLI主程序的配置调用。
"""

import os
import logging
from pathlib import Path
from typing import Dict, Any, Optional, List, Tuple

from .global_config import GlobalConfigManager, create_global_config
from .config import BackupConfigLoader


class ConfigManager:
    """配置管理器
    
    提供统一的配置管理功能，包括全局配置和备份配置的加载。
    """
    
    def __init__(self, main_config_path: str = "/etc/database-backup/db.toml"):
        """初始化配置管理器
        
        参数:
            main_config_path (str): 主配置文件路径
                示例值: "/etc/database-backup/db.toml"
        """
        self.main_config_path = Path(main_config_path)
        self.global_config = None
        self.backup_config_loader = None
        self.logger = logging.getLogger('database_backup.config')
    
    def initialize_global_config(self) -> bool:
        """初始化全局配置
        
        返回:
            bool: 初始化是否成功
                示例值: True
        """
        try:
            self.global_config = create_global_config(str(self.main_config_path))
            return True
        except Exception as e:
            self.logger.error(f"初始化全局配置失败: {e}")
            return False
    
    def initialize_backup_config(self, config_dir: Optional[str] = None) -> bool:
        """初始化备份配置
        
        参数:
            config_dir (Optional[str]): 备份配置目录，None表示使用全局配置中的设置
                示例值: "/etc/database-backup/conf.d/"
        
        返回:
            bool: 初始化是否成功
                示例值: True
        """
        try:
            # 确定配置目录：优先使用传入参数，其次使用全局配置中的设置
            if not config_dir and self.global_config:
                config_dir = self.global_config.get_config_dir()
                self.logger.info(f"使用全局配置文件中的配置目录: {config_dir}")
            
            if not config_dir:
                self.logger.error("未指定配置目录且全局配置中未设置")
                return False
            
            self.backup_config_loader = BackupConfigLoader(config_dir)
            return True
        except Exception as e:
            self.logger.error(f"初始化备份配置失败: {e}")
            return False
    
    def initialize_for_backup(self, config_dir: Optional[str] = None) -> bool:
        """为备份操作进行完整的配置初始化
        
        参数:
            config_dir (Optional[str]): 备份配置目录
        
        返回:
            bool: 初始化是否成功
        """
        # 检查并生成主配置文件（如果不存在）
        if self.check_and_generate_main_config():
            self.logger.info("主配置文件已生成，请根据实际情况修改后重新运行")
            return False
        
        # 初始化全局配置
        if not self.initialize_global_config():
            self.logger.error("初始化全局配置失败")
            return False
        
        # 初始化备份配置
        if not self.initialize_backup_config(config_dir):
            self.logger.error("初始化备份配置失败")
            return False
        
        return True
    
    def load_backup_configs_with_validation(self, config_file: Optional[str] = None) -> List[Dict[str, Any]]:
        """加载备份配置文件并进行验证
        
        参数:
            config_file (Optional[str]): 指定配置文件路径
        
        返回:
            List[Dict[str, Any]]: 加载的配置列表，如果失败返回空列表
        """
        config_list = self.load_backup_configs(config_file)
        if not config_list:
            config_dir = self.get_config_dir()
            self.logger.error(f"未找到任何有效的配置文件，请检查目录: {config_dir}")
            return []
        
        self.logger.info(f"找到 {len(config_list)} 个备份任务配置")
        return config_list
    
    def check_and_generate_main_config(self) -> bool:
        """检查并生成主配置文件
        
        如果主配置文件不存在，则生成默认配置文件。
        
        返回:
            bool: 是否需要生成配置文件（True表示已生成，False表示已存在）
                示例值: True
        """
        if not self.main_config_path.exists():
            self.logger.info(f"主配置文件不存在: {self.main_config_path}")
            self.logger.info("正在生成默认主配置文件...")
            
            # 生成默认主配置文件
            self._generate_main_config()
            
            self.logger.info(f"默认主配置文件已生成: {self.main_config_path}")
            self.logger.info("请根据实际情况修改配置文件中的参数")
            return True
        
        return False
    
    def _generate_main_config(self) -> None:
        """生成默认主配置文件
        
        使用全局配置管理器生成默认配置文件。
        """
        try:
            # 确保父目录存在
            self.main_config_path.parent.mkdir(parents=True, exist_ok=True)
            
            # 创建全局配置管理器实例
            config_manager = GlobalConfigManager()
            
            # 生成默认配置
            config_manager.generate_default_config(str(self.main_config_path))
            
        except Exception as e:
            self.logger.error(f"生成主配置文件失败: {e}")
            raise
    
    def validate_backup_configs(self) -> Dict[str, Any]:
        """验证备份配置文件
        
        返回:
            Dict[str, Any]: 验证结果，包含成功和失败的配置
                示例值: {'success': [...], 'failed': [...]}
        """
        if not self.backup_config_loader:
            self.logger.error("备份配置加载器未初始化")
            return {'success': [], 'failed': []}
        
        try:
            return self.backup_config_loader.load_all_configs_with_status()
        except Exception as e:
            self.logger.error(f"验证备份配置失败: {e}")
            return {'success': [], 'failed': []}
    
    def load_backup_configs(self, config_file: Optional[str] = None) -> List[Dict[str, Any]]:
        """加载备份配置文件
        
        每次调用都会重新从文件系统读取配置文件，实现动态配置加载。
        
        参数:
            config_file (Optional[str]): 指定配置文件路径，None表示加载所有配置
                示例值: "/etc/database-backup/conf.d/mysql.toml"
        
        返回:
            List[Dict[str, Any]]: 加载的配置列表
                示例值: [{...}, {...}]
        """
        try:
            if config_file:
                # 加载指定配置文件
                if not os.path.exists(config_file):
                    self.logger.error(f"配置文件不存在: {config_file}")
                    return []
                
                config_loader = BackupConfigLoader(os.path.dirname(config_file))
                config = config_loader.load_single_config(config_file)
                return [config] if config else []
            else:
                # 加载所有配置文件
                if not self.backup_config_dir or not os.path.exists(self.backup_config_dir):
                    self.logger.warning(f"备份配置目录不存在: {self.backup_config_dir}")
                    return []
                
                # 每次都重新创建备份配置加载器，确保获取最新配置
                config_loader = BackupConfigLoader(self.backup_config_dir)
                return config_loader.load_all_configs()
        except Exception as e:
            self.logger.error(f"加载备份配置失败: {e}")
            return []
    
    def get_max_workers(self) -> int:
        """获取最大并发工作线程数
        
        返回:
            int: 最大并发工作线程数
        """
        # 从全局配置中获取最大工作线程数，如果未设置则返回默认值4
        if self.global_config:
            return self.global_config.get('backup', {}).get('max_workers', 4)
        return 4
    
    def get_config_files_info(self) -> Dict[str, Any]:
        """获取配置文件信息
        
        返回:
            Dict[str, Any]: 包含配置文件信息的字典
        """
        # 获取配置目录
        config_dir = self.get_config_dir()
        
        info = {
            'global_config_file': str(self.main_config_path),
            'global_config_exists': self.main_config_path.exists(),
            'backup_config_dir': config_dir,
            'backup_config_dir_exists': os.path.exists(config_dir),
            'backup_config_files': []
        }
        
        # 获取备份配置文件列表
        if os.path.exists(config_dir):
            try:
                config_files = list(Path(config_dir).glob('*.toml'))
                info['backup_config_files'] = [str(f) for f in config_files]
                info['backup_config_count'] = len(config_files)
            except Exception as e:
                self.logger.error(f"获取备份配置文件列表时发生错误: {e}")
                info['backup_config_count'] = 0
        else:
            info['backup_config_count'] = 0
        
        return info
    
    def get_config_dir(self) -> str:
        """获取配置目录
        
        返回:
            str: 配置目录路径
                示例值: "/etc/database-backup/conf.d/"
        """
        if self.global_config:
            return self.global_config.get_config_dir()
        return "/etc/database-backup/conf.d/"  # 默认值


def create_config_manager(main_config_path: str = "/etc/database-backup/db.toml") -> ConfigManager:
    """创建配置管理器实例
    
    参数:
        main_config_path (str): 主配置文件路径
            示例值: "/etc/database-backup/db.toml"
    
    返回:
        ConfigManager: 配置管理器实例
    """
    return ConfigManager(main_config_path)